﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml.Serialization;
using System.Globalization;
using VectorMath;

namespace XMLSerializerBase
{
    public class BasicSerialization
    {
        public bool CreateSerial(string filename)
        {
            //place an in memory object here that represents your class representation of the building
            List<EPObj.MemorySafe_Spaces> myspace = new List<EPObj.MemorySafe_Spaces>();
            myspace = EnergyPlusClass.EPlusSpacestoObjectList(@"C:\Users\Chiensi\Documents\C\Buro Happold\Oregon Sustainability Center\Run 1 + Daylighting Only\Run 1 new.idf");

            gb.gbci = new CultureInfo(String.Empty);
            
            bool ret = false;
            //needed  to store all unique planes in the project
            List<PlanarGeometry> uniquesurf = new List<PlanarGeometry>();
            Dictionary<string, PlanarGeometry> uniqueplanes = new Dictionary<string, PlanarGeometry>();
            Dictionary<string, Surface> uniquesurfaces = new Dictionary<string, Surface>();

            //the basics
            //constructor to define the basics
            gbXML gbx = new gbXML();
            gbx.lengthUnit = lengthUnitEnum.Feet;
            gbx.temperatureUnit = gbXML.temperatureUnitEnum.F;
            string id = "cmps-1";
            Campus cmp = CreateCampus(id);
            cmp.Buildings = new Building[10000];
            gbx.Campus = cmp;

            //where does this location information from?  it could be smartly inferred somehow, but otherwise specified by the user/programmer
            Location zeloc = new Location();
            zeloc.Name = "San Francisco, CA";
            zeloc.Latitude = 37.795;
            zeloc.Longitude = -122.394;
            //end the basics
            //tie location and campus back to the gbXML file
            cmp.Location = zeloc;
            
            //Define the building(s) on the site
            //CHarriman Septempber 19 2013
            cmp.Buildings[0] = MakeBuilding(2000);

            //CHarriman September 19 2013
            //define the stories for each building
            //several ways to do this
            List<List<double>> points = prod.MakeFakeList(5);
            BuildingStorey bs = MakeStorey(1, points);

            //CHarriman Jan 15 2014
            //define the spaces for each building (these come from a space object elsewhere
            int spacecount = 0;
            foreach (EPObj.MemorySafe_Spaces space in myspace)
            {
                //foreach Space space in your ListofSpaces
                Space zespace = new Space();
                zespace.id = "Space-1";
                zespace.lightScheduleIdRef = "lightSchedule-1";
                zespace.equipmentScheduleIdRef = "equipmentSchedule-1";
                zespace.peopleScheduleIdRef = "peopleSchedule-1";
                zespace.conditionType = "HeatedAndCooled";
                zespace.buildingStoreyIdRef = "bldg-story-1";
                zespace.Name = "Test Space";
                zespace.peoplenum = 12;
                zespace.totalpeoplegain = 450;
                zespace.senspeoplegain = 250;
                zespace.latpeoplegain = 200;
                zespace.PeopleHeatGains = new PeopleHeatGain[3];
                zespace.lpd = 1.2;
                zespace.epd = 1.5;
                zespace.Area = 2450;
                zespace.Volume = 24500;
                zespace.PlanarGeo = new PlanarGeometry();
                zespace.ShellGeo = new ShellGeometry();


                PeopleNumber pn = new PeopleNumber();
                pn.peopleunits = peopleNumberUnitEnum.NumberOfPeople;

                string people = gb.FormatDoubleToString(zespace.peoplenum);
                pn.valuefield = people;
                zespace.PeopleNumber = pn;

                PeopleHeatGain phg = new PeopleHeatGain();
                phg.loadunits = peopleHeatGainUnitEnum.BtuPerHourPerson;
                phg.loadtype = peopleHeatGainTypeEnum.Total;
                string totalpopload = gb.FormatDoubleToString(zespace.totalpeoplegain);
                phg.value = totalpopload;
                zespace.PeopleHeatGains[0] = phg;

                PeopleHeatGain shg = new PeopleHeatGain();
                shg.loadunits = peopleHeatGainUnitEnum.BtuPerHourPerson;
                shg.loadtype = peopleHeatGainTypeEnum.Sensible;
                string senspopload = gb.FormatDoubleToString(zespace.senspeoplegain);
                shg.value = senspopload;
                zespace.PeopleHeatGains[1] = shg;

                PeopleHeatGain lhg = new PeopleHeatGain();
                lhg.loadunits = peopleHeatGainUnitEnum.BtuPerHourPerson;
                lhg.loadtype = peopleHeatGainTypeEnum.Latent;
                string latpopload = gb.FormatDoubleToString(zespace.latpeoplegain);
                lhg.value = latpopload;
                zespace.PeopleHeatGains[2] = lhg;

                LightPowerPerArea lpd = new LightPowerPerArea();
                lpd.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
                lpd.lpd = gb.FormatDoubleToString(zespace.lpd);
                zespace.LightPowerPerArea = lpd;

                EquipPowerPerArea epd = new EquipPowerPerArea();
                epd.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
                epd.epd = gb.FormatDoubleToString(zespace.epd);
                zespace.EquipPowerPerArea = epd;

                Area spacearea = new Area();
                spacearea.val = gb.FormatDoubleToString(zespace.Area);
                zespace.spacearea = spacearea;

                Volume spacevol = new Volume();
                spacevol.val = gb.FormatDoubleToString(zespace.Volume);
                zespace.spacevol = spacevol;

                //same as the planar geometry of the floor planes above
                PlanarGeometry spaceplpoly = new PlanarGeometry();
                //get a list of points that makes up the polyloop
                List<List<double>> spacepoints = prod.MakeFakeList(3);
                //make polyloop with points
                spaceplpoly.PolyLoop = new PolyLoop();
                spaceplpoly.PolyLoop = prod.MakePolyLoops(spaceplpoly.PolyLoop, spacepoints);
                zespace.PlanarGeo = spaceplpoly;
                //@@
                //ShellGeometry
                //similar to planar geometry, but with more planes
                ShellGeometry sg = new ShellGeometry();
                sg.unit = lengthUnitEnum.Feet;
                sg.id = "sg" + space.name;
                sg.ClosedShell = new ClosedShell();
                //up to 100 surfaces per space?  base on the space instance surfaces
                sg.ClosedShell.PolyLoops = new PolyLoop[space.spaceSurfaces.Count()];
                //I would have a list of surface elements that make up the space surfaces.
                //each surface would consist of a series of points that defines the surface.
                for (int i = 0; i < space.spaceSurfaces.Count(); i++)
                {
                    //get points from the space surfaces
                    List<List<double>> epluspoints = new List<List<double>>();
                    epluspoints = EnergyPlusClass.GetCoordinDoubles(space.spaceSurfaces[i].SurfaceCoords);
                    sg.ClosedShell.PolyLoops[i] = new PolyLoop();
                    sg.ClosedShell.PolyLoops[i] = prod.MakePolyLoops(sg.ClosedShell.PolyLoops[i], epluspoints);
                }
                zespace.ShellGeo = sg;

                zespace.cadid = new CADObjectId();
                zespace.cadid.id = "990099";
                //make surface boundaries..special code needed so that space boundaries are not duplicated...
                //option 1 : the surfaces already declared as internal somehow and how shared.
                //option 2:  the api tries to figure it out
                zespace.spbound = new SpaceBoundary[space.spaceSurfaces.Count()];
                int psurfacecount = 0;
                for (int i = 0; i < space.spaceSurfaces.Count(); i++)
                {
                    //get points from the space surfaces
                    List<List<double>> epluspoints = new List<List<double>>();
                    epluspoints = EnergyPlusClass.GetCoordinDoubles(space.spaceSurfaces[i].SurfaceCoords);
                    //if surface is exterior
                    SpaceBoundary sb = new SpaceBoundary();
                    zespace.spbound[i] = prod.MakeSpaceBoundary(sb,epluspoints, psurfacecount);
                    
                    psurfacecount++;
                    //else if surface is interior and it has not been listed before
                    //then do the same
                    //else do nothing because it is interior and it has already been listed
                    

                    //I also would like to keep track of all the surfaces that I create to better prepare me for the surface definition
                    uniquesurf.Add(zespace.spbound[i].PlanarGeometry);
                    //make a dictionary that stores the name of a surface and its planar geometry?
                    uniqueplanes.Add(zespace.spbound[i].surfaceIdRef, zespace.spbound[i].PlanarGeometry);
                    //make a dictionary that stores the name of a surface and create a surface as the value
                    
                    Surface newsurface = new Surface();
                    //this took a lot of customization...a user would have to make their own code to attach to my object here
                    newsurface = prod.SetUpSurfaceFromIDF(space.spaceSurfaces[i], zespace.spbound[i].PlanarGeometry);
                    uniquesurfaces.Add(zespace.spbound[i].surfaceIdRef, newsurface);
                }

    
                cmp.Buildings[0].Spaces[spacecount] = zespace;
                spacecount++;

            }

            //after making all the spaces, I make the surfaces
            cmp.Surface = new Surface[uniquesurfaces.Count()];
            int surfcount = 0;
            foreach (KeyValuePair<string, Surface> pair in uniquesurfaces)
            {
                Surface surf = new Surface();
                surf.id = pair.Key;
                //this is a hard one, how to deal with this?  For now, everything is external, and idf can sort of tell me
                surf.surfaceType = pair.Value.surfaceType;
                surf.constructionIdRef = pair.Value.constructionIdRef;
                surf.Name = pair.Value.Name;
                AdjacentSpaceId[] adjspaces = new AdjacentSpaceId[pair.Value.AdjacentSpaceId.Count()];
                int counter = 0;
                foreach (AdjacentSpaceId adj in pair.Value.AdjacentSpaceId)
                {
                    adjspaces[counter] = adj;
                    counter++;
                }
                surf.AdjacentSpaceId = adjspaces;
                RectangularGeometry rg = new RectangularGeometry();
                rg = pair.Value.RectangularGeometry;
                surf.RectangularGeometry = rg;
                surf.PlanarGeometry = pair.Value.PlanarGeometry;
                cmp.Surface[surfcount] = surf;
                surfcount++;
            }
            

            cmp.Buildings[0].bldgStories[0] = bs;

            //write xml to the file
            XmlSerializer szer = new XmlSerializer(typeof(gbXML));
            TextWriter tw = new StreamWriter(filename);
            szer.Serialize(tw, gbx);
            tw.Close();

            return ret;
        }

        private Campus CreateCampus(string id)
        {
            Campus cmp = new Campus();
            cmp.id = id;
            return cmp;

        }

        private Building MakeBuilding(double bldarea)
        {
            Building zeb = new Building();
            zeb.Area = bldarea;
            //this has been arbitrarily defined and could be changed
            zeb.bldgStories = new BuildingStorey[1000];
            zeb.Spaces = new Space[10000];
            return zeb;
        }

        private List<Building> MakeBuildings(List<double> bldareas)
        {
            List<Building> blds = new List<Building>();
            foreach (double area in bldareas)
            {
                blds.Add(MakeBuilding(area));
            }
            return blds;
        }

        private BuildingStorey MakeStorey(int levelnum, List<List<double>> points)
        {
            BuildingStorey bs = new BuildingStorey();
            bs.id = "bldg-story-"+levelnum;
            bs.Name = "Level "+levelnum;
            bs.Level = Convert.ToDouble(levelnum-1);

            //there is only one plane per storey
            PlanarGeometry pg = new PlanarGeometry();            
            //make polyloop with points
            pg.PolyLoop = new PolyLoop();
            //uses just a simple set of points = List<List<double>>
            pg.PolyLoop = prod.MakePolyLoops(pg.PolyLoop, points);
            //add polyloop to the building storey object
            bs.PlanarGeo = pg;
            return bs;
        }

        //same but from a series of Vector Cartesian Coordinates
        private BuildingStorey MakeStorey(int levelnum, List<Vector.MemorySafe_CartCoord> points)
        {
            BuildingStorey bs = new BuildingStorey();
            bs.id = "bldg-story-" + levelnum;
            bs.Name = "Level " + levelnum;
            bs.Level = Convert.ToDouble(levelnum - 1);

            //there is only one plane per storey
            PlanarGeometry pg = new PlanarGeometry();
            //make polyloop with points
            pg.PolyLoop = new PolyLoop();
            //uses just a simple set of points = List<List<double>>
            pg.PolyLoop = prod.MakePolyLoops(pg.PolyLoop, points);
            //add polyloop to the building storey object
            bs.PlanarGeo = pg;
            return bs;
        }

        private List<BuildingStorey> MakeStories(List<List<Vector.MemorySafe_CartCoord>> pointslist)
        {
            List<BuildingStorey> stories = new List<BuildingStorey>();
            for (int i = 1; i <= pointslist.Count(); i++)
            {
                BuildingStorey bs = new BuildingStorey();
                bs.id = "bldg-story-" + i;
                bs.Name = "Level " + i;
                bs.Level = Convert.ToDouble(i - 1);

                //there is only one plane per storey
                PlanarGeometry pg = new PlanarGeometry();
                //make polyloop with points
                pg.PolyLoop = new PolyLoop();
                //uses just a simple set of points = List<List<double>>
                pg.PolyLoop = prod.MakePolyLoops(pg.PolyLoop, pointslist[i]);
                //add polyloop to the building storey object
                bs.PlanarGeo = pg;
                stories.Add(bs);
            }
            return stories;
        }
    }
}
